home *** CD-ROM | disk | FTP | other *** search
/ System Booster / System Booster.iso / Archives / MoreHardware / GALer20.lha / GALer20 / Source / GALer / Checker.c next >
Encoding:
C/C++ Source or Header  |  1996-04-05  |  29.9 KB  |  965 lines
  1. /******************************************************************************
  2. ** Checker.c
  3. *******************************************************************************
  4. **
  5. ** description:
  6. **
  7. ** This file contains the GAL-Checker.
  8. **
  9. ******************************************************************************/
  10.  
  11.  
  12.  
  13.  
  14.  
  15.  
  16. /********************************* includes **********************************/
  17.  
  18. #include <libraries/mui.h>
  19.  
  20. #include <intuition/intuition.h>
  21. #include <stdio.h>
  22. #include <string.h>
  23.  
  24. #include <clib/alib_protos.h>
  25.  
  26. #include <proto/locale.h>
  27. #include <proto/graphics.h>
  28. #include <proto/intuition.h>
  29.  
  30. #include "GALer.h"
  31. #include "Localize.h"
  32.  
  33.  
  34.  
  35.  
  36.  
  37. /********************************** defines **********************************/
  38.  
  39.  
  40.  
  41.  
  42.  
  43. /********************************* functions *********************************/
  44.  
  45. static void  SetLevel(int pinnum, int level);
  46.  
  47. static void  CheckOutput(void);
  48.  
  49. static int   GadID2Pin(int gadID);
  50.  
  51.  
  52.  
  53.  
  54.  
  55. /********************************* variables *********************************/
  56.  
  57.  
  58. extern  struct  AppString { LONG   as_ID;
  59.                             STRPTR as_Str;
  60.                           };
  61.  
  62. extern  struct  AppString AppStrings[];
  63.  
  64. extern  int     checker_mode;
  65. extern  int     gal_type;
  66. extern  int     asmreadyflag;
  67. extern  int     num_of_pins;
  68.  
  69. extern  UBYTE   PinNames[24][10];
  70.  
  71. extern  APTR    main_win;
  72.  
  73. extern  APTR    menustrip, menu_project, menu_galtype, menu_gal, menu_asm,
  74.                 menu_galdis, menu_tools, menu_checker;
  75.  
  76. extern  APTR    GAL_txt[], GAL_gads[];
  77.  
  78.  
  79.  
  80.  
  81.  
  82. int     GALType;
  83. int     outIC1, outIC2, outIC3, outIC4, outIC5;
  84.  
  85.  
  86.  
  87. struct  in_con    { int IC;
  88.                     int Bit;
  89.                     int IO;
  90.                     int Level;
  91.                   };
  92.  
  93. struct  out_con   { int IC;
  94.                     int Bit;
  95.                   };
  96.  
  97.  
  98.  
  99.  
  100.             /* 1. entry: IC which controls the pin                      */
  101.             /* 2. entry: bit of this IC which controls the pin          */
  102.             /* 3. entry: shows whether a pin is used as input or output */
  103.             /* 4. entry: shows level of this pin                        */
  104.  
  105. struct in_con  in_bit[23] = {
  106.  
  107.                 {IC4, 0x01, INPUT_PIN,  LOW},    /* pin  1 */
  108.                 {IC4, 0x02, INPUT_PIN,  LOW},    /* pin  2 */
  109.                 {IC4, 0x04, INPUT_PIN,  LOW},    /* pin  3 */
  110.                 {IC4, 0x08, INPUT_PIN,  LOW},    /* pin  4 */
  111.                 {IC4, 0x10, INPUT_PIN,  LOW},    /* pin  5 */
  112.                 {IC4, 0x20, INPUT_PIN,  LOW},    /* pin  6 */
  113.                 {IC4, 0x40, INPUT_PIN,  LOW},    /* pin  7 */
  114.                 {IC4, 0x80, INPUT_PIN,  LOW},    /* pin  8 */
  115.                 {IC5, 0x01, INPUT_PIN,  LOW},    /* pin  9 */
  116.                 {IC5, 0x02, INPUT_PIN,  LOW},    /* pin 10 */
  117.                 {IC5, 0x04, INPUT_PIN,  LOW},    /* pin 11 */
  118.                 { 0,   0,      0,        0 },    /*  GND   */
  119.                 {IC5, 0x08, INPUT_PIN,  LOW},    /* pin 13 */
  120.                 {IC5, 0x10, INPUT_PIN,  LOW},    /* pin 14 */
  121.                 {IC5, 0x20, OUTPUT_PIN, LOW},    /* pin 15 */
  122.                 {IC3, 0x01, OUTPUT_PIN, LOW},    /* pin 16 */
  123.                 {IC3, 0x02, OUTPUT_PIN, LOW},    /* pin 17 */
  124.                 {IC3, 0x04, OUTPUT_PIN, LOW},    /* pin 18 */
  125.                 {IC3, 0x08, OUTPUT_PIN, LOW},    /* pin 19 */
  126.                 {IC3, 0x10, OUTPUT_PIN, LOW},    /* pin 20 */
  127.                 {IC3, 0x20, OUTPUT_PIN, LOW},    /* pin 21 */
  128.                 {IC3, 0x40, OUTPUT_PIN, LOW},    /* pin 22 */
  129.                 {IC3, 0x80, INPUT_PIN,  LOW}     /* pin 23 */
  130.  
  131.                             };
  132.  
  133.  
  134.  
  135.                                 /* 1. entry: IC which can read the pin */
  136.                                 /* 2. entry: bit of this IC            */
  137.  
  138. struct out_con out_bit[10] = { { IC7,  0x01 },
  139.                                { IC7,  0x02 },
  140.                                { IC7,  0x04 },
  141.                                { IC7,  0x08 },
  142.                                { IC7,  0x10 },
  143.                                { IC7,  0x20 },
  144.                                { IC7,  0x40 },
  145.                                { IC7,  0x80 },
  146.                                { IC6a, 0x01 },
  147.                                { IC6c, 0x01 } };
  148.  
  149.  
  150.  
  151.  
  152.  
  153.  
  154.     /* The following figure shows where the parts of the symbolic GAL are */
  155.     /* stored. The used variables are GAL_gads[] and GAL_txt[].           */
  156.  
  157.     /*  input:    name:               name:   output:   input:    in/out: */
  158.     /*                                                                    */
  159.     /*                    ---- ----                                       */
  160.     /* gads[ 0]  txt[ 0]  | 1   24|  txt[23]                              */
  161.     /* gads[ 1]  txt[ 1]  | 2   23|  txt[22]  txt[33]  gads[21]  gads[31] */
  162.     /* gads[ 2]  txt[ 2]  | 3   22|  txt[21]  txt[32]  gads[20]  gads[30] */
  163.     /* gads[ 3]  txt[ 3]  | 4   21|  txt[20]  txt[31]  gads[19]  gads[29] */
  164.     /* gads[ 4]  txt[ 4]  | 5   20|  txt[19]  txt[30]  gads[18]  gads[28] */
  165.     /* gads[ 5]  txt[ 5]  | 6   19|  txt[18]  txt[29]  gads[17]  gads[27] */
  166.     /* gads[ 6]  txt[ 6]  | 7   18|  txt[17]  txt[28]  gads[16]  gads[26] */
  167.     /* gads[ 7]  txt[ 7]  | 8   17|  txt[16]  txt[27]  gads[15]  gads[25] */
  168.     /* gads[ 8]  txt[ 8]  | 9   16|  txt[15]  txt[26]  gads[14]  gads[24] */
  169.     /* gads[ 9]  txt[ 9]  |10   15|  txt[14]  txt[25]  gads[13]  gads[23] */
  170.     /* gads[10]  txt[10]  |11   14|  txt[13]  txt[24]  gads[12]  gads[22] */
  171.     /*           txt[11]  |12   13|  txt[12]           gads[11]           */
  172.     /*                    ---------                                       */
  173.  
  174.  
  175.  
  176.  
  177.  
  178.  
  179. /******************************************************************************
  180. ** Checker()
  181. *******************************************************************************
  182. ** input:   gadID       ID of the selected gadget of the symbolic GAL
  183. **
  184. ** output:  none
  185. **
  186. ** remarks: sets gadget texts and gadgets of the symbolic GAL according to
  187. **          the users actions
  188. ******************************************************************************/
  189.  
  190. void Checker(ULONG gadID)
  191. {
  192.     UBYTE   c, *txt;
  193.  
  194.                                     /* get character of the */
  195.                                     /* selected gadget      */
  196.  
  197.     get(GAL_gads[gadID - 1], MUIA_Text_Contents, &txt);
  198.  
  199.     c = *txt;
  200.  
  201.  
  202.                             /*** input gadgets ***/
  203.     if (gadID >= 1 && gadID <= 22)
  204.     {
  205.         if (c == 'L')                   /* level of input pin was low */
  206.         {                               /* set it to high             */
  207.  
  208.             set(GAL_gads[gadID - 1], MUIA_Text_Contents, "H");
  209.  
  210.             in_bit[GadID2Pin(gadID) - 1].Level = HIGH;
  211.  
  212.             SetLevel(GadID2Pin(gadID), HIGH);
  213.         }
  214.         else
  215.         {                               /* level of input pin was high */
  216.                                         /* set it to low               */
  217.  
  218.             set(GAL_gads[gadID - 1], MUIA_Text_Contents, "L");
  219.  
  220.             in_bit[GadID2Pin(gadID) - 1].Level = LOW;
  221.  
  222.             SetLevel(GadID2Pin(gadID), LOW);
  223.         }
  224.     }
  225.  
  226.                                         /*** input/output gadgets (I/O) ***/
  227.  
  228.     if (gadID >= 23 && gadID <= 32)
  229.     {
  230.         if (c == 'O')                       /* pin is set as an output  */
  231.         {                                   /* so change it to an input */
  232.  
  233.             set(GAL_gads[gadID - 1], MUIA_Text_Contents, "I");
  234.  
  235.                                             /* enable input level gadget */
  236.  
  237.             set(GAL_gads[gadID - 11], MUIA_Disabled, FALSE);
  238.  
  239.                                             /* disable output level */
  240.  
  241.             set(GAL_txt[gadID + 1], MUIA_Disabled, TRUE);
  242.  
  243.  
  244.             SetLevel(GadID2Pin(gadID), LOW);
  245.  
  246.             in_bit[GadID2Pin(gadID) - 1].IO = INPUT_PIN;
  247.         }
  248.         else
  249.         {                                   /* pin is set as an input    */
  250.                                             /* so change it to an output */
  251.  
  252.             set(GAL_gads[gadID - 1], MUIA_Text_Contents, "O");
  253.  
  254.                                             /* disable input level gadget */
  255.  
  256.             set(GAL_gads[gadID - 11], MUIA_Disabled, TRUE);
  257.  
  258.                                             /* enable output level */
  259.  
  260.             set(GAL_txt[gadID + 1], MUIA_Disabled, FALSE);
  261.  
  262.  
  263.             in_bit[GadID2Pin(gadID) - 1].IO = OUTPUT_PIN;
  264.  
  265.             SetLevel(GadID2Pin(gadID), LOW);
  266.         }
  267.  
  268.     }
  269.  
  270.  
  271.     CheckOutput();
  272. }
  273.  
  274.  
  275.  
  276.  
  277.  
  278. /******************************************************************************
  279. ** ToggleChecker()
  280. *******************************************************************************
  281. ** input:   none
  282. **
  283. ** output:  none
  284. **
  285. ** remarks: switchs the GAL checker on/off
  286. ******************************************************************************/
  287.  
  288. void ToggleChecker(void)
  289. {
  290.     int     n;
  291.  
  292.  
  293.     if (checker_mode)
  294.     {                                           /* exit GAL checker */
  295.  
  296.                         /* remove the checker's menu and add the main menu */
  297.  
  298.         DoMethod(menustrip, MUIM_Family_Remove, menu_checker);
  299.  
  300.         DoMethod(menustrip, MUIM_Family_AddHead, menu_project);
  301.         DoMethod(menustrip, MUIM_Family_AddTail, menu_galtype);
  302.         DoMethod(menustrip, MUIM_Family_AddTail, menu_gal);
  303.         DoMethod(menustrip, MUIM_Family_AddTail, menu_asm);
  304.         DoMethod(menustrip, MUIM_Family_AddTail, menu_galdis);
  305.         DoMethod(menustrip, MUIM_Family_AddTail, menu_tools);
  306.  
  307.  
  308.  
  309.         LED(OFF);
  310.  
  311.         WriteByte(0x00, IC3);                   /* set all pins to low */
  312.         WriteByte(0x00, IC4);
  313.         WriteByte(0x00, IC5);
  314.  
  315.         DisableVcc();
  316.  
  317.  
  318.  
  319.         checker_mode = OFF;
  320.                                                 /* reset gadget text */
  321.  
  322.  
  323.         switch (GALType)            /* set text and de-/activate gadgets */
  324.         {
  325.             case GAL16V8:
  326.  
  327.                 DoMethod(main_win, MUIM_MultiSet, MUIA_Disabled, FALSE,
  328.                         GAL_gads[12], GAL_gads[13], GAL_gads[14], GAL_gads[15],
  329.                         GAL_gads[16], GAL_gads[17], GAL_gads[18], GAL_gads[19],
  330.                         GAL_txt[24],  GAL_txt[25],  GAL_txt[26],  GAL_txt[27],
  331.                         GAL_txt[28],  GAL_txt[29],  GAL_txt[30],  GAL_txt[31],
  332.                         NULL);
  333.  
  334.                 DoMethod(main_win, MUIM_MultiSet, MUIA_Text_Contents, "L",
  335.                         GAL_gads[ 2], GAL_gads[ 3], GAL_gads[ 4], GAL_gads[ 5],
  336.                         GAL_gads[ 6], GAL_gads[ 7], GAL_gads[ 8], GAL_gads[ 9],
  337.                         GAL_gads[10], GAL_gads[11], GAL_gads[12], GAL_gads[13],
  338.                         GAL_gads[14], GAL_gads[15], GAL_gads[16], GAL_gads[17],
  339.                         GAL_gads[18], GAL_gads[19], NULL);
  340.  
  341.                 DoMethod(main_win, MUIM_MultiSet, MUIA_Text_Contents, "O",
  342.                         GAL_gads[22], GAL_gads[23], GAL_gads[24], GAL_gads[25],
  343.                         GAL_gads[26], GAL_gads[27], GAL_gads[28], GAL_gads[29],
  344.                         NULL);
  345.  
  346.                 DoMethod(main_win, MUIM_MultiSet, MUIA_Text_Contents, "Z",
  347.                         GAL_txt[24], GAL_txt[25], GAL_txt[26], GAL_txt[27],
  348.                         GAL_txt[28], GAL_txt[29], GAL_txt[30], GAL_txt[31],
  349.                         NULL);
  350.                 break;
  351.  
  352.  
  353.             case GAL20V8:
  354.  
  355.                 DoMethod(main_win, MUIM_MultiSet, MUIA_Disabled, FALSE,
  356.                         GAL_gads[13], GAL_gads[14], GAL_gads[15], GAL_gads[16],
  357.                         GAL_gads[17], GAL_gads[18], GAL_gads[19], GAL_gads[20],
  358.                         GAL_txt[25],  GAL_txt[26],  GAL_txt[27],  GAL_txt[28],
  359.                         GAL_txt[29],  GAL_txt[30],  GAL_txt[31],  GAL_txt[32],
  360.                         NULL);
  361.  
  362.                 DoMethod(main_win, MUIM_MultiSet, MUIA_Text_Contents, "L",
  363.                         GAL_gads[ 0], GAL_gads[ 1], GAL_gads[ 2], GAL_gads[ 3],
  364.                         GAL_gads[ 4], GAL_gads[ 5], GAL_gads[ 6], GAL_gads[ 7],
  365.                         GAL_gads[ 8], GAL_gads[ 9], GAL_gads[10], GAL_gads[11],
  366.                         GAL_gads[12], GAL_gads[13], GAL_gads[14], GAL_gads[15],
  367.                         GAL_gads[16], GAL_gads[17], GAL_gads[18], GAL_gads[19],
  368.                         GAL_gads[20], GAL_gads[21], NULL);
  369.  
  370.                 DoMethod(main_win, MUIM_MultiSet, MUIA_Text_Contents, "O",
  371.                         GAL_gads[23], GAL_gads[24], GAL_gads[25], GAL_gads[26],
  372.                         GAL_gads[27], GAL_gads[28], GAL_gads[29], GAL_gads[30],
  373.                         NULL);
  374.  
  375.                 DoMethod(main_win, MUIM_MultiSet, MUIA_Text_Contents, "Z",
  376.                         GAL_txt[25], GAL_txt[26], GAL_txt[27], GAL_txt[28],
  377.                         GAL_txt[29], GAL_txt[30], GAL_txt[31], GAL_txt[32],
  378.                         NULL);
  379.                 break;
  380.  
  381.  
  382.             case GAL22V10:
  383.             case GAL20RA10:
  384.  
  385.                 DoMethod(main_win, MUIM_MultiSet, MUIA_Disabled, FALSE,
  386.                         GAL_gads[12], GAL_gads[13], GAL_gads[14], GAL_gads[15],
  387.                         GAL_gads[16], GAL_gads[17], GAL_gads[18], GAL_gads[19],
  388.                         GAL_gads[20], GAL_gads[21],
  389.                         GAL_txt[24],  GAL_txt[25],  GAL_txt[26],  GAL_txt[27],
  390.                         GAL_txt[28],  GAL_txt[29],  GAL_txt[30],  GAL_txt[31],
  391.                         GAL_txt[32],  GAL_txt[33],  NULL);
  392.  
  393.                 DoMethod(main_win, MUIM_MultiSet, MUIA_Text_Contents, "L",
  394.                         GAL_gads[ 0], GAL_gads[ 1], GAL_gads[ 2], GAL_gads[ 3],
  395.                         GAL_gads[ 4], GAL_gads[ 5], GAL_gads[ 6], GAL_gads[ 7],
  396.                         GAL_gads[ 8], GAL_gads[ 9], GAL_gads[10], GAL_gads[11],
  397.                         GAL_gads[12], GAL_gads[13], GAL_gads[14], GAL_gads[15],
  398.                         GAL_gads[16], GAL_gads[17], GAL_gads[18], GAL_gads[19],
  399.                         GAL_gads[20], GAL_gads[21], NULL);
  400.  
  401.                 DoMethod(main_win, MUIM_MultiSet, MUIA_Text_Contents, "O",
  402.                         GAL_gads[22], GAL_gads[23], GAL_gads[24], GAL_gads[25],
  403.                         GAL_gads[26], GAL_gads[27], GAL_gads[28], GAL_gads[29],
  404.                         GAL_gads[30], GAL_gads[31], NULL);
  405.  
  406.                 DoMethod(main_win, MUIM_MultiSet, MUIA_Text_Contents, "Z",
  407.                         GAL_txt[24], GAL_txt[25], GAL_txt[26], GAL_txt[27],
  408.                         GAL_txt[28], GAL_txt[29], GAL_txt[30], GAL_txt[31],
  409.                         GAL_txt[32], GAL_txt[33], NULL);
  410.                 break;
  411.         }
  412.  
  413.     }
  414.     else
  415.     {
  416.         if (GALTypeRequest(AppStrings[MSG_GAL_CHECKER].as_Str))
  417.         {
  418.                             /* remove main menu and add the checker's menu */
  419.  
  420.             DoMethod(menustrip, MUIM_Family_Remove, menu_project);
  421.             DoMethod(menustrip, MUIM_Family_Remove, menu_galtype);
  422.             DoMethod(menustrip, MUIM_Family_Remove, menu_gal);
  423.             DoMethod(menustrip, MUIM_Family_Remove, menu_asm);
  424.             DoMethod(menustrip, MUIM_Family_Remove, menu_galdis);
  425.             DoMethod(menustrip, MUIM_Family_Remove, menu_tools);
  426.  
  427.             DoMethod(menustrip, MUIM_Family_AddHead, menu_checker);
  428.  
  429.  
  430.  
  431.             WriteByte(0x00, IC3);           /* set all pins to low */
  432.             WriteByte(0x00, IC4);
  433.             WriteByte(0x00, IC5);
  434.  
  435.                                             /* initialize in_bit array */
  436.             for (n = 0; n < 23; n++)
  437.             {
  438.                 in_bit[n].Level = LOW;
  439.                 in_bit[n].IO    = INPUT_PIN;
  440.             }
  441.  
  442.             in_bit[14].IO = OUTPUT_PIN;       /* pins 15 to 21 can always */
  443.             in_bit[15].IO = OUTPUT_PIN;       /* be outputs */
  444.             in_bit[16].IO = OUTPUT_PIN;
  445.             in_bit[17].IO = OUTPUT_PIN;
  446.             in_bit[18].IO = OUTPUT_PIN;
  447.             in_bit[19].IO = OUTPUT_PIN;
  448.             in_bit[20].IO = OUTPUT_PIN;
  449.  
  450.  
  451.             switch (GALType)                    /* de-/activate gadgets */
  452.             {
  453.                 case GAL16V8:
  454.                     in_bit[13].IO = OUTPUT_PIN;
  455.  
  456.                     DoMethod(main_win, MUIM_MultiSet, MUIA_Disabled, FALSE,
  457.                             GAL_txt[24], GAL_txt[25], GAL_txt[26], GAL_txt[27],
  458.                             GAL_txt[28], GAL_txt[29], GAL_txt[30], GAL_txt[31],
  459.                             NULL);
  460.  
  461.                     DoMethod(main_win, MUIM_MultiSet, MUIA_Disabled, TRUE,
  462.                             GAL_gads[12], GAL_gads[13], GAL_gads[14], GAL_gads[15],
  463.                             GAL_gads[16], GAL_gads[17], GAL_gads[18], GAL_gads[19],
  464.                             NULL);
  465.                     break;
  466.  
  467.  
  468.                 case GAL20V8:
  469.                     in_bit[21].IO = OUTPUT_PIN;
  470.  
  471.                     DoMethod(main_win, MUIM_MultiSet, MUIA_Disabled, FALSE,
  472.                             GAL_txt[25], GAL_txt[26], GAL_txt[27], GAL_txt[28],
  473.                             GAL_txt[29], GAL_txt[30], GAL_txt[31], GAL_txt[32],
  474.                             NULL);
  475.  
  476.                     DoMethod(main_win, MUIM_MultiSet, MUIA_Disabled, TRUE,
  477.                             GAL_gads[13], GAL_gads[14], GAL_gads[15], GAL_gads[16],
  478.                             GAL_gads[17], GAL_gads[18], GAL_gads[19], GAL_gads[20],
  479.                             NULL);
  480.                     break;
  481.  
  482.  
  483.                 case GAL22V10:
  484.                 case GAL20RA10:
  485.                     in_bit[13].IO = OUTPUT_PIN;
  486.                     in_bit[21].IO = OUTPUT_PIN;
  487.                     in_bit[22].IO = OUTPUT_PIN;
  488.  
  489.                     DoMethod(main_win, MUIM_MultiSet, MUIA_Disabled, FALSE,
  490.                             GAL_txt[24], GAL_txt[25], GAL_txt[26], GAL_txt[27],
  491.                             GAL_txt[28], GAL_txt[29], GAL_txt[30], GAL_txt[31],
  492.                             GAL_txt[32], GAL_txt[33], NULL);
  493.  
  494.                     DoMethod(main_win, MUIM_MultiSet, MUIA_Disabled, TRUE,
  495.                             GAL_gads[12], GAL_gads[13], GAL_gads[14], GAL_gads[15],
  496.                             GAL_gads[16], GAL_gads[17], GAL_gads[18], GAL_gads[19],
  497.                             GAL_gads[20], GAL_gads[21], NULL);
  498.                     break;
  499.             }
  500.  
  501.  
  502.  
  503.             LED(ON);
  504.  
  505.             EnableVcc();
  506.  
  507.             checker_mode = ON;                        /* init. checker */
  508.  
  509.             WaitForTimer(100000L);
  510.  
  511.             CheckOutput();                            /* test outputs */
  512.  
  513.         }
  514.     }
  515. }
  516.  
  517.  
  518.  
  519.  
  520.  
  521. /******************************************************************************
  522. ** SetLevel()
  523. *******************************************************************************
  524. ** input:   pinnum      pin number
  525. **          level       level of the pin
  526. **
  527. ** output:  none
  528. **
  529. ** remarks: This function sets the level (= H or L) of a pin of the ZIF
  530. **          socket.
  531. ******************************************************************************/
  532.  
  533. static void SetLevel(int pinnum, int level)
  534. {
  535.     int     bits, ICnum, outIC;
  536.  
  537.  
  538.  
  539.     ICnum = in_bit[pinnum - 1].IC;              /* get IC number and output */
  540.     bits  = in_bit[pinnum - 1].Bit;             /* bit of this IC           */
  541.  
  542.  
  543.     if (ICnum == IC3)
  544.         outIC = outIC3;
  545.  
  546.     if (ICnum == IC4)
  547.         outIC = outIC4;
  548.  
  549.     if (ICnum == IC5)
  550.         outIC = outIC5;
  551.  
  552.  
  553.     bits ^= 0xFF;                         /* invert all bits */
  554.  
  555.     outIC &= bits;                        /* set the output bit of the IC */
  556.  
  557.     if (level == HIGH)
  558.     {
  559.         bits ^= 0xFF;
  560.         outIC |= bits;
  561.     }
  562.  
  563.     WriteByte(outIC, ICnum);              /* set level of pin */
  564.  
  565. }
  566.  
  567.  
  568.  
  569.  
  570.  
  571. /******************************************************************************
  572. ** CheckOutput()
  573. *******************************************************************************
  574. ** input:   none
  575. **
  576. ** output:  none
  577. **
  578. ** remarks: This function checks whether an output is High, Low or Tristate.
  579. ******************************************************************************/
  580.  
  581. static void CheckOutput(void)
  582. {
  583.     int n, in_bits, out_bits, pin_level;
  584.     int inICnum, outICnum, outIC, byte, first_out, last_out;
  585.  
  586.  
  587.  
  588.     switch (GALType)                    /* get possible output pins */
  589.     {
  590.         case GAL16V8:
  591.             first_out = 14;
  592.             last_out  = 21;
  593.             break;
  594.  
  595.         case GAL20V8:
  596.             first_out = 15;
  597.             last_out  = 22;
  598.             break;
  599.  
  600.         case GAL22V10:
  601.         case GAL20RA10:
  602.             first_out = 14;
  603.             last_out  = 23;
  604.             break;
  605.     }
  606.  
  607.  
  608.     for (n = first_out; n <= last_out; n++)
  609.     {                                           /* check all outputs */
  610.  
  611.         if (in_bit[n - 1].IO == OUTPUT_PIN)
  612.         {
  613.  
  614.             outICnum = in_bit[n - 1].IC;
  615.             out_bits = in_bit[n - 1].Bit;
  616.  
  617.             inICnum  = out_bit[n - 14].IC;
  618.             in_bits  = out_bit[n - 14].Bit;
  619.  
  620.  
  621.             if (outICnum == IC3)
  622.                 outIC = outIC3;
  623.  
  624.             if (outICnum == IC4)
  625.                 outIC = outIC4;
  626.  
  627.             if (outICnum == IC5)
  628.                 outIC = outIC5;
  629.  
  630.  
  631.             byte = ReadByte(inICnum);       /* get level of the output pins */
  632.  
  633.             if (byte & in_bits)
  634.                 pin_level = HIGH;           /* "calculate" level of outputs */
  635.             else
  636.                 pin_level = LOW;
  637.  
  638.  
  639.             outIC |= out_bits;              /* set output HIGH */
  640.             WriteByte(outIC, outICnum);
  641.  
  642.             byte = ReadByte(inICnum);       /* get level of the output pins */
  643.                                             /* again                        */
  644.  
  645.  
  646.             if (pin_level != (1 && (byte & in_bits)))
  647.             {                           /* the output can be set high and low */
  648.                                         /* so its a high impedance output     */
  649.  
  650.                 set(GAL_txt[n + 10], MUIA_Text_Contents, "Z");
  651.             }
  652.             else
  653.             {
  654.                 if (pin_level == LOW)
  655.                     set(GAL_txt[n + 10], MUIA_Text_Contents, "L");
  656.                 else
  657.                     set(GAL_txt[n + 10], MUIA_Text_Contents, "H");
  658.             }
  659.  
  660.  
  661.             outIC &= (out_bits^0xFF);       /* set output LOW again */
  662.             WriteByte(outIC, outICnum);
  663.         }
  664.     }
  665. }
  666.  
  667.  
  668.  
  669.  
  670.  
  671. /******************************************************************************
  672. ** SetSymbolGAL()
  673. *******************************************************************************
  674. ** input:   type   type of GAL
  675. ** output:  none
  676. **
  677. ** remarks: draws symbolic GAL according to the type of GAL
  678. ******************************************************************************/
  679.  
  680. void SetSymbolGAL(int gal_type)
  681. {
  682.  
  683.                     /* enable/disable gadgets and text fields */
  684.                     /* and set pin numbers according to the   */
  685.                     /* selected type of GAL                   */
  686.  
  687.     switch (gal_type)
  688.     {
  689.         case GAL16V8:
  690.             DoMethod(main_win, MUIM_MultiSet, MUIA_Disabled, TRUE,
  691.                 GAL_gads[0],  GAL_gads[1], GAL_gads[20], GAL_gads[21],
  692.                 GAL_gads[30], GAL_gads[31],
  693.                 GAL_txt[0],   GAL_txt[1], GAL_txt[22], GAL_txt[23], NULL);
  694.  
  695.             DoMethod(main_win, MUIM_MultiSet, MUIA_Text_Contents, "",
  696.                 GAL_gads[0],  GAL_gads[1], GAL_gads[20], GAL_gads[21],
  697.                 GAL_gads[30], GAL_gads[31],
  698.                 GAL_txt[0],   GAL_txt[1],  GAL_txt[22], GAL_txt[23],
  699.                 GAL_txt[32],  GAL_txt[33], NULL);
  700.  
  701.  
  702.             DoMethod(GAL_gads[22], MUIM_Set, MUIA_Disabled, FALSE);
  703.  
  704.             set(GAL_gads[22], MUIA_Text_Contents, "O");
  705.             set(GAL_txt[24],  MUIA_Text_Contents, "Z");
  706.  
  707.             break;
  708.  
  709.  
  710.         case GAL20V8:
  711.             DoMethod(main_win, MUIM_MultiSet, MUIA_Disabled, FALSE,
  712.                 GAL_gads[0],  GAL_gads[1], GAL_gads[20], GAL_gads[21],
  713.                 GAL_gads[30],
  714.                 GAL_txt[0],   GAL_txt[1], GAL_txt[22], GAL_txt[23], NULL);
  715.  
  716.  
  717.             DoMethod(main_win, MUIM_MultiSet, MUIA_Disabled, TRUE,
  718.                 GAL_gads[22], GAL_gads[31], NULL);
  719.  
  720.             DoMethod(main_win, MUIM_MultiSet, MUIA_Text_Contents, "",
  721.                 GAL_gads[22], GAL_gads[31],
  722.                 GAL_txt[24],  GAL_txt[33], NULL);
  723.  
  724.  
  725.             DoMethod(main_win, MUIM_MultiSet, MUIA_Text_Contents, "L",
  726.                 GAL_gads[0], GAL_gads[1], GAL_gads[20], GAL_gads[21], NULL);
  727.  
  728.             set(GAL_gads[30], MUIA_Text_Contents, "O");
  729.             set(GAL_txt[32],  MUIA_Text_Contents, "Z");
  730.  
  731.             break;
  732.  
  733.  
  734.         case GAL22V10:
  735.         case GAL20RA10:
  736.             DoMethod(main_win, MUIM_MultiSet, MUIA_Disabled, FALSE,
  737.                 GAL_gads[0],  GAL_gads[1], GAL_gads[20], GAL_gads[21],
  738.                 GAL_gads[22], GAL_gads[30], GAL_gads[31],
  739.                 GAL_txt[0],   GAL_txt[1], GAL_txt[22], GAL_txt[23], NULL);
  740.  
  741.             DoMethod(main_win, MUIM_MultiSet, MUIA_Text_Contents, "L",
  742.                 GAL_gads[0], GAL_gads[1], GAL_gads[20], GAL_gads[21], NULL);
  743.  
  744.             DoMethod(main_win, MUIM_MultiSet, MUIA_Text_Contents, "O",
  745.                 GAL_gads[22], GAL_gads[30], GAL_gads[31], NULL);
  746.  
  747.             DoMethod(main_win, MUIM_MultiSet, MUIA_Text_Contents, "Z",
  748.                 GAL_txt[24], GAL_txt[32], GAL_txt[33], NULL);
  749.  
  750.             break;
  751.     }
  752.  
  753.  
  754.     ResetPinNames();                /* set pin names/numbers */
  755. }
  756.  
  757.  
  758.  
  759.  
  760.  
  761. /******************************************************************************
  762. ** PrintPinNames()
  763. *******************************************************************************
  764. ** input:   none
  765. **
  766. ** output:  none
  767. **
  768. ** remarks: This function does print the pin names at the symbolic GAL.
  769. ******************************************************************************/
  770.  
  771. void PrintPinNames(void)
  772. {
  773.     int     start, end, n;
  774.  
  775.     char    string[20];
  776.     char    number[8];
  777.  
  778.  
  779.  
  780.     if (asmreadyflag)
  781.     {                                   /* is there an assembled file?  */
  782.         if (gal_type == GALType)
  783.         {                               /* is the type of the GAL o.k.? */
  784.  
  785.             if (GALType == GAL16V8)     /* GAL16V8: */
  786.             {
  787.                 start =  2;             /* first pin has index 2  */
  788.                 end   = 21;             /* last  pin has index 21 */
  789.             }
  790.             else
  791.             {                           /* GAL20V8, 22V10, 20RA10 */
  792.                 start =  0;
  793.                 end   = 23;
  794.             }
  795.  
  796.  
  797.             for (n = start; n <= end; n++)
  798.             {
  799.                                 /* make string containing the pin name */
  800.                                 /* and the according pin number        */
  801.  
  802.                 if (n < 12)             /* left side of the symbolic GAL  */
  803.                 {
  804.                                         /* first pin name then pin number */
  805.  
  806.                     strcpy(string, "\33r");
  807.  
  808.                     strcat(string, (const char *)&PinNames[n - start][0]);
  809.  
  810.                     if (n - start + 1 < 10)
  811.                         strcat(string, "  \33b");
  812.                     else
  813.                         strcat(string, " \33b");
  814.  
  815.                     sprintf(number, "%d", n - start + 1);
  816.  
  817.                     strcat(string, (const char *)number);
  818.  
  819.                 }
  820.                 else                    /* right side of the symbolic GAL */
  821.                 {
  822.                                         /* first pin number then pin name */
  823.  
  824.                     sprintf(number, "\33b%d\33n ", n - start + 1);
  825.  
  826.                     strcpy(string, (const char *)number);
  827.  
  828.                     strcat(string, (const char *)&PinNames[n - start][0]);
  829.  
  830.                 }
  831.  
  832.                 set(GAL_txt[n], MUIA_Text_Contents, string);
  833.             }
  834.  
  835.         }
  836.         else
  837.         {
  838.             ErrorReq(9);                             /* wrong GAL selected */
  839.         }
  840.     }
  841.     else
  842.     {
  843.         ErrorReq(7);                                 /* no names to print*/
  844.     }
  845.  
  846. }
  847.  
  848.  
  849.  
  850.  
  851.  
  852. /******************************************************************************
  853. ** PrintPinNames()
  854. *******************************************************************************
  855. ** input:   none
  856. **
  857. ** output:  none
  858. **
  859. ** remarks: This function does assign "noname" to the pins of the
  860. **          symbolic GAL.
  861. ******************************************************************************/
  862.  
  863. void ResetPinNames(void)
  864. {
  865.     int n, start, end;
  866.  
  867.     char    string[20];
  868.     char    number[8];
  869.  
  870.  
  871.  
  872.     if (GALType == GAL16V8)     /* GAL16V8: */
  873.     {
  874.         start =  2;             /* first pin at index 2  */
  875.         end   = 21;             /* last  pin at index 21 */
  876.     }
  877.     else
  878.     {                           /* GAL20V8, 22V10, 20RA10 */
  879.         start =  0;
  880.         end   = 23;
  881.     }
  882.  
  883.  
  884.     for (n = start; n <= end; n++)
  885.     {
  886.                         /* make string containing the pin name */
  887.                         /* and the according pin number        */
  888.  
  889.         if (n < 12)             /* left side of the symbolic GAL  */
  890.         {
  891.                                 /* first pin name then pin number */
  892.  
  893.             strcpy(string, "\33rnoname");
  894.  
  895.             if (n - start + 1 < 10)
  896.                 strcat(string, "  \33b");
  897.             else
  898.                 strcat(string, " \33b");
  899.  
  900.             sprintf(number, "%d", n - start + 1);
  901.  
  902.             strcat(string, (const char *)number);
  903.  
  904.         }
  905.         else                    /* right side of the symbolic GAL */
  906.         {
  907.                                 /* first pin number then pin name */
  908.  
  909.             sprintf(number, "\33b%d\33n ", n - start + 1);
  910.  
  911.             strcpy(string, (const char *)number);
  912.  
  913.             strcat(string, "noname");
  914.  
  915.         }
  916.  
  917.         set(GAL_txt[n], MUIA_Text_Contents, string);
  918.     }
  919.  
  920. }
  921.  
  922.  
  923.  
  924.  
  925.  
  926. /******************************************************************************
  927. ** GadID2Pin()
  928. *******************************************************************************
  929. ** input:   gadID       gadget ID
  930. **
  931. ** output:              pin number
  932. **                      -1: can't connect the gadget ID with a pin
  933. **
  934. ** remarks: This function transforms a gadget ID of the symbolic GAL to the
  935. **          according pin number of the ZIF socket.
  936. ******************************************************************************/
  937.  
  938. static int GadID2Pin(int gadID)
  939. {
  940.     int pin;
  941.  
  942.  
  943.  
  944.     pin = -1;
  945.  
  946.  
  947.     if (gadID >= 1 && gadID <= 11)              /* input gadgets left  */
  948.         pin = gadID;
  949.     else
  950.         if (gadID >= 12 && gadID <= 22)         /* input gadgets right */
  951.             pin = gadID + 1;
  952.         else
  953.             if (gadID >= 23 && gadID <= 32)     /* in/out selection    */
  954.                 pin = gadID - 9;
  955.  
  956.  
  957.     return (pin);
  958. }
  959.  
  960.  
  961.  
  962.  
  963.  
  964. /* EOF */
  965.